/*	Comun.c
 *
 *  Creado el: 07/09/2010
 *      Autor: Diego A.
 *
 */

#include "LogFile.h"
#include "LibreriasComunes.h"

/*sem_t *semLog;*/

pthread_mutex_t semLog;


int logLevel = 4;

int getLogLevel(){
	return logLevel;
}
void setLogLevel (int level){
	logLevel=level;
}

pthread_mutex_t *log_getSemLog(){
	return &semLog;
}

void dc_setSemLog(pthread_mutex_t semaforo){
	semLog=semaforo;
}

int getCurrentProcessInfo( char *sNombreProceso, char *sDir )
{
	int iLonguitudProcFullPath;
	char sProcFullPath[FILENAME_MAX];
	char *ptrUltimaBarra;

	memset(sProcFullPath,'\0', FILENAME_MAX);

	/*Esto es portable en cualquier plataforma linux, no Unix.*/
	iLonguitudProcFullPath = readlink("/proc/self/exe", sProcFullPath, FILENAME_MAX - 1);
	if ( iLonguitudProcFullPath <= 0 )
	{
		perror("No se pudo obtener el path donde ejecuta el proceso actual.");
		return 1;
	}
	ptrUltimaBarra = strrchr(sProcFullPath,'/');
	/*Obtiene el nombre del proceso actual sin el / inicial y le concatena la extension .conf*/
	strcpy(sNombreProceso,ptrUltimaBarra+1);
	ptrUltimaBarra[0] = '\0'; /*setear nulo en la ultima barra para que el string termine ahi.*/
	strcpy(sDir,sProcFullPath);

	return 0;
}

static int buildLogLine(const char iNivelError,char *sResultado, const char *sFormato, va_list args )
{
	time_t tmpTiempo;
	struct tm *ahora;
	char sDatoActual[50];
	char sNombreProceso[256];
	char sDirProceso[1024];
	int iProcId;
	int iThreadId;
	char sMensajeFinal[4096] = "";
	char sNivelError[10] = "";


	if ( strlen(sFormato) > 4096-1 )
		return 1;

	switch (iNivelError) {
		case LOG_ERR:
			strcpy(sNivelError,"ERROR");
			break;
		case LOG_WARN:
			strcpy(sNivelError,"WARN");
			break;
		case LOG_INFO:
			strcpy(sNivelError,"INFO");
			break;
		case LOG_DEBUG:
			strcpy(sNivelError,"DEBUG");
			break;
		default:
			strcpy(sNivelError,"UNKNOWN");
			break;
	}
	/* Creo el string de la hora*/
	tmpTiempo = time(NULL);
	ahora = localtime(&tmpTiempo);
	/*
	sprintf(
		sDatoActual,
		"%02i/%02i/%02i %02i:%02i:%02i",
		ahora->tm_
		ahora->tm_hour,
		ahora->tm_min,
		ahora->tm_sec,
		0);
	*/
	strftime ( sDatoActual,50, "%d-%m-%Y %H:%M:%S",ahora);
	/* Obtengo la informacion del proceso*/
	/*getCurrentProcessInfo(sNombreProceso,sDirProceso);*/
	/*iProcId = getpid();*/
	/*iThreadId = pthread_self(); *//* podría ser gettid() tambien*/
	strcpy(sNombreProceso,"RAID");

	/* Creo el campo de informacion */
	 vsprintf(sMensajeFinal,sFormato,args);

	/* Creo la linea */
	sprintf(
		sResultado,
/*		"%s %s [%i][%i]: %s: %s\r\n",*/
		"%s [%s]: %s: %s\r\n",
/*		sDatoActual,sNombreProceso,iProcId,iThreadId,sNivelError,sMensajeFinal);*/
		sDatoActual,sNombreProceso,sNivelError,sMensajeFinal);
	return 0;
}

int logMessage(const char iNivelError, char *sMsg, ... )
{
	const char *sNombreArchivoLog = "/home/utn_so/logRAID";
	char sNombreProceso[FILENAME_MAX];
	char sDirProceso[FILENAME_MAX];
	char sRutaArchivoLog[FILENAME_MAX];
	FILE *fLog;
	char sLinea[1024*10] = "";
	va_list args;
	/*static unsigned char logLevel = 0;*/
	static char *logLevelStr;

	/*Obtener el nivel de log la primera vez*/
	/*if ( logLevel == 0 )
	{
		logLevelStr = getenv("TP_LOG_LEVEL");
		logLevel = logLevelStr != NULL ? (char)atoi(logLevelStr) : LOG_DEFAULT_LEVEL;
	}*/

	/*Omitir el logueo si no corresponde de acuerdo a la severidad maxima seteada  */
	if ( logLevel < iNivelError )
		return 0;

	/*Construir el path absoluto del archivo de log*/
	/*getCurrentProcessInfo(sNombreProceso,sDirProceso);
	strcpy(sRutaArchivoLog,sDirProceso);
	strcat(sRutaArchivoLog,"/");*/
	strcpy(sRutaArchivoLog,sNombreArchivoLog);


	/*Convertir argumentos variables y pasarselos a la funcion buildLogLine*/
	va_start(args,sMsg);
	buildLogLine(iNivelError,sLinea,sMsg,args);
	va_end(args);
	
	if( pthread_mutex_lock(log_getSemLog())==-1){
				 printf(">>>>>>>>>>>>>>>>>>>>>ERRRORR SUPERLOCO CON SEMAFORO DE LOG\n");
	 }else{
			printf("----> lockee semaforo LOG\n");
	 }

	/*sem_wait(semLog);*/
	if ( (fLog = fopen(sRutaArchivoLog,"a")) == NULL )
	{
		printf( "No se pudo abrir el archivo de log: %s\n",sRutaArchivoLog);
		return 1; /* Could not open the file.*/
	}
	fwrite(sLinea,1,strlen(sLinea),fLog);
	fclose(fLog);

	if( pthread_mutex_unlock(log_getSemLog())==-1){
		printf(">>>>>>>>>>>>>>>>>>>>>ERRRORR SUPERLOCO CON SEMAFORO DE LOG\n");
	 }else{
		 printf("----> desLockee semaforo LOG\n");
	 }

	/*printf(sLinea);*/
	/*sem_post(semLog);*/
	return 0;
}

/*-----------------------------------------------------------------------------	*/
/* SEMAFOROS:                                                                  	*/
/*	 SEM1 = entrada asociada al nombre en el filesystem (/dev/shm/<nombre>)		*/
/*	 O_CREAT = flag, si no existe lo crea, sino lo usa (ojo permisos y cambios) */
/*	 S_IRUSR|S_IWUSR = modo, aca es escritura y lectura para usuario.           */
/*	 1 = valor inicial del semaforo.                                            */
/*-----------------------------------------------------------------------------	*/

int inicializarSemaforos(char *nombreSemLog)
{
	/*if ((semLog = sem_open(nombreSemLog,O_CREAT,S_IRUSR|S_IWUSR,1)) == SEM_FAILED)
	{
		perror("OPEN - Comun - Error En Creacion De Semaforo LogAll");
		return 1;
	}

	if ( sem_post(semLog) != 0 )
	{
		perror("POST - Comun - Error En Creacion De Semaforo LogAll");
		return 1;
	}*/
	return 0;
}


void initSemLog(){
	pthread_mutex_init(log_getSemLog(), NULL);
}

int existeArchivo( char *sPathAbsoluto )
{
	FILE * f;
	int iExiste;

	f = fopen(sPathAbsoluto,"r");
	iExiste = f != NULL;
	if ( f != NULL ) fclose(f);
	return iExiste;
}
